[原创] 连载 5 - 深入讨论 Android 关于高效显示图片的问题 - 如何在 UI 中显示位图

更加详细的说明，可以参阅如下官网地址：http://developer.android.com/training/building-graphics.html
快速导航

1. 如何高效的加载大位图。（如何解码大位图，避免超过每个应用允许使用的最大内存）http://yhz61010.iteye.com/blog/1848337
2. 如何在非 UI 线程处理位图。（如何使用 AsyncTask 在后台线程处理位图及处理并发问题）http://yhz61010.iteye.com/blog/1848811
3. 如何对位图进行缓存。（如何通过创建内存缓存和磁盘缓存来流畅的显示多张位图）http://yhz61010.iteye.com/blog/1849645
4. 如何管理位图内存。（如何针对不同的 Android 版本管理位图内存）http://yhz61010.iteye.com/blog/1850232
5. 如何在 UI 中显示位图。（如何通过 ViewPager 和 GridView 显示多张图片）http://yhz61010.iteye.com/blog/1852927
   如何在 UI 中显示位图？
   本文将引导你将前四篇的文章结合在一起，为你演示如何使用 ViewPager 和 GridView 组件在后台线程组合缓存加载多张位图，并且还将为你演示如何处理并发及配置改变的问题。
   实现向 ViewPager 中添加位图
   在浏览大量图片时，若允许用户滑动屏幕就可以切换图片的话，是非常好的导航模式 http://developer.android.com/design/patterns/swipe-views.html。你可以使用 ViewPager 组件的 PagerAdapter 来实现这种导航方式。但若使用它的子类 FragmentStatePagerAdapter 可能更加合适，因为当图片不再被显示的时候，该类会自动清理并保存 ViewPager 中的 Fragments 的状态，以节约内存的使用量。
   注意，若你只想展示少量的图片，并且可以保证这些图片所占的内存不会超过应用程序的内存限制的话，那么你可以使用普通的 PagerAdapter 或 FragmentPagerAdapter 即可。
   现在将为你展示如何使用 ViewPager 显示多个 ImageView。在主 activity 中声明了 ViewPager 和 adapter：

   public class ImageDetailActivity extends FragmentActivity {
       public static final String EXTRA_IMAGE = "extra_image";
       private ImagePagerAdapter mAdapter;
       private ViewPager mPager;
   // A static dataset to back the ViewPager adapter
       public final static Integer[] imageResIds = new Integer[] {
               R.drawable.sample_image_1, R.drawable.sample_image_2, R.drawable.sample_image_3,
               R.drawable.sample_image_4, R.drawable.sample_image_5, R.drawable.sample_image_6,
               R.drawable.sample_image_7, R.drawable.sample_image_8, R.drawable.sample_image_9};
       @Override
       public void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.image_detail_pager); // Contains just a ViewPager
           mAdapter = new ImagePagerAdapter(getSupportFragmentManager(), imageResIds.length);
           mPager = (ViewPager) findViewById(R.id.pager);
           mPager.setAdapter(mAdapter);
       }
       public static class ImagePagerAdapter extends FragmentStatePagerAdapter {
           private final int mSize;
           public ImagePagerAdapter(FragmentManager fm, int size) {
               super(fm);
               mSize = size;
           }
           @Override
           public int getCount() {
               return mSize;
           }
           @Override
           public Fragment getItem(int position) {
               return ImageDetailFragment.newInstance(position);
           }
       }
   }

   下面的代码为你详细的展现了持有 ImageView 的 Fragment 的实现。下面的代码看似是个完美的解决办法，但是你看出其中的不足了吗？应该如何改进呢？

   public class ImageDetailFragment extends Fragment {
       private static final String IMAGE_DATA_EXTRA = "resId";
       private int mImageNum;
       private ImageView mImageView;
       static ImageDetailFragment newInstance(int imageNum) {
           final ImageDetailFragment f = new ImageDetailFragment();
           final Bundle args = new Bundle();
           args.putInt(IMAGE_DATA_EXTRA, imageNum);
           f.setArguments(args);
           return f;
       }
   // Empty constructor, required as per Fragment docs
       public ImageDetailFragment() {}
       @Override
       public void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           mImageNum = getArguments() != null ? getArguments().getInt(IMAGE_DATA_EXTRA) : -1;
       }
       @Override
       public View onCreateView(LayoutInflater inflater, ViewGroup container,
               Bundle savedInstanceState) {
   // image_detail_fragment.xml contains just an ImageView
           final View v = inflater.inflate(R.layout.image_detail_fragment, container, false);
           mImageView = (ImageView) v.findViewById(R.id.imageView);
           return v;
       }
       @Override
       public void onActivityCreated(Bundle savedInstanceState) {
           super.onActivityCreated(savedInstanceState);
           final int resId = ImageDetailActivity.imageResIds[mImageNum];
           mImageView.setImageResource(resId); // Load image into ImageView
       }
   }

   你可能注意到问题的所在，图片是在 UI 线程中被加载的，这可能导致你的程序没有响应或被强制关闭。使用前文 http://yhz61010.iteye.com/blog/1848811 提到的 AsyncTask 来解决这个问题，将加载图片的处理放到后台线程来处理：

   public class ImageDetailActivity extends FragmentActivity {
       ...
       public void loadBitmap(int resId, ImageView imageView) {
           mImageView.setImageResource(R.drawable.image_placeholder);
           BitmapWorkerTask task = new BitmapWorkerTask(mImageView);
           task.execute(resId);
       }
       ... // include BitmapWorkerTask class
   }
   public class ImageDetailFragment extends Fragment {
       ...
       @Override
       public void onActivityCreated(Bundle savedInstanceState) {
           super.onActivityCreated(savedInstanceState);
           if (ImageDetailActivity.class.isInstance(getActivity())) {
               final int resId = ImageDetailActivity.imageResIds[mImageNum];
   // Call out to ImageDetailActivity to load the bitmap in a background thread
               ((ImageDetailActivity) getActivity()).loadBitmap(resId, mImageView);
           }
       }
   }

   将任何耗时的处理（例如，获取来自网络中的图片或调整其大小）放到 BitmapWorkerTask 中，这样就不会给主 UI 线程带来任何响应的问题。后台线程的工作不仅仅是从磁盘中直接加载图片，而且还应该包括对图片进行缓存处理，这一点在 http://yhz61010.iteye.com/admin/blogs/1849645 一文中已经有了深入的讨论。下面，我们对代码做进一步的修改，以支持对内存缓存的处理：

   public class ImageDetailActivity extends FragmentActivity {
       ...
       private LruCache<String, Bitmap> mMemoryCache;
       @Override
       public void onCreate(Bundle savedInstanceState) {
           ...
   // initialize LruCache as per Use a Memory Cache section
       }
       public void loadBitmap(int resId, ImageView imageView) {
           final String imageKey = String.valueOf(resId);
           final Bitmap bitmap = mMemoryCache.get(imageKey);
           if (bitmap != null) {
               mImageView.setImageBitmap(bitmap);
           } else {
               mImageView.setImageResource(R.drawable.image_placeholder);
               BitmapWorkerTask task = new BitmapWorkerTask(mImageView);
               task.execute(resId);
           }
       }
       ... // include updated BitmapWorkerTask from Use a Memory Cache section
   }

   将上述代码结合在一起，你就得到了一个响应及时的 ViewPager 实现。在该实现中，你可以以最小的延迟在后台对图片进行各种各样的处理。
   实现向 GridView 中添加位图
   Grid List http://developer.android.com/design/building-blocks/grid-lists.html 特别适用于显示图片集。通过 GridView 组件可以实现一次性在屏幕中显示多张图片，并且可以提前为用户准备好上下滑动屏幕时需要显示的图片。若要实现这种类型的操作，我们必须保证用户使用的流畅性，并且内存的使用量是可控的，而且还要保证并发操作的正确性（因为 GridView 会重用它的子视图）。
   在开始了解具体的实现之前，我们先来看一个在 Fragment 中，使用带有 ImageView 的标准的 GridView 实现代码。然后再来分析下，这看似完美的实现方式背后还有没有更好的实现方式？

   public class ImageGridFragment extends Fragment implements AdapterView.OnItemClickListener {
       private ImageAdapter mAdapter;
   // A static dataset to back the GridView adapter
       public final static Integer[] imageResIds = new Integer[] {
               R.drawable.sample_image_1, R.drawable.sample_image_2, R.drawable.sample_image_3,
               R.drawable.sample_image_4, R.drawable.sample_image_5, R.drawable.sample_image_6,
               R.drawable.sample_image_7, R.drawable.sample_image_8, R.drawable.sample_image_9};
   // Empty constructor as per Fragment docs
       public ImageGridFragment() {}
       @Override
       public void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           mAdapter = new ImageAdapter(getActivity());
       }
       @Override
       public View onCreateView(
               LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
           final View v = inflater.inflate(R.layout.image_grid_fragment, container, false);
           final GridView mGridView = (GridView) v.findViewById(R.id.gridView);
           mGridView.setAdapter(mAdapter);
           mGridView.setOnItemClickListener(this);
           return v;
       }
       @Override
       public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
           final Intent i = new Intent(getActivity(), ImageDetailActivity.class);
           i.putExtra(ImageDetailActivity.EXTRA_IMAGE, position);
           startActivity(i);
       }
       private class ImageAdapter extends BaseAdapter {
           private final Context mContext;
           public ImageAdapter(Context context) {
               super();
               mContext = context;
           }
           @Override
           public int getCount() {
               return imageResIds.length;
           }
           @Override
           public Object getItem(int position) {
               return imageResIds[position];
           }
           @Override
           public long getItemId(int position) {
               return position;
           }
           @Override
           public View getView(int position, View convertView, ViewGroup container) {
               ImageView imageView;
               if (convertView == null) { // if it's not recycled, initialize some attributes
                   imageView = new ImageView(mContext);
                   imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
                   imageView.setLayoutParams(new GridView.LayoutParams(
                           LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
               } else {
                   imageView = (ImageView) convertView;
               }
               imageView.setImageResource(imageResIds[position]); // Load image into ImageView
               return imageView;
           }
       }
   }

   上述代码的问题和之前的例子一样，对图片的处理依然放在了 UI 线程。对于展示小的图片来说，这么做可能不会产生任何问题，但是如果我们还需要对显示的图片进行额外的处理话，上面的代码很可能会导致你的程序崩溃。
   虽然这次我们依然可以使用刚才提到的异步处理及缓存处理，但是依然要谨慎的做好并发处理，因为 GridView 会重用它的子视图。为了处理这个问题，我们可以使用在 http://yhz61010.iteye.com/blog/1848811 一文中，“并发处理”章节中使用的技术。下面是对上述代码的改进版：

   public class ImageGridFragment extends Fragment implements AdapterView.OnItemClickListener {
       ...
       private class ImageAdapter extends BaseAdapter {
           ...
           @Override
           public View getView(int position, View convertView, ViewGroup container) {
               ...
               loadBitmap(imageResIds[position], imageView)
               return imageView;
           }
       }
       public void loadBitmap(int resId, ImageView imageView) {
           if (cancelPotentialWork(resId, imageView)) {
               final BitmapWorkerTask task = new BitmapWorkerTask(imageView);
               final AsyncDrawable asyncDrawable =
                       new AsyncDrawable(getResources(), mPlaceHolderBitmap, task);
               imageView.setImageDrawable(asyncDrawable);
               task.execute(resId);
           }
       }
       static class AsyncDrawable extends BitmapDrawable {
           private final WeakReference<BitmapWorkerTask> bitmapWorkerTaskReference;
           public AsyncDrawable(Resources res, Bitmap bitmap,
                   BitmapWorkerTask bitmapWorkerTask) {
               super(res, bitmap);
               bitmapWorkerTaskReference =
                   new WeakReference<BitmapWorkerTask>(bitmapWorkerTask);
           }
           public BitmapWorkerTask getBitmapWorkerTask() {
               return bitmapWorkerTaskReference.get();
           }
       }
       public static boolean cancelPotentialWork(int data, ImageView imageView) {
           final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);
           if (bitmapWorkerTask != null) {
               final int bitmapData = bitmapWorkerTask.data;
               if (bitmapData != data) {
   // Cancel previous task
                   bitmapWorkerTask.cancel(true);
               } else {
   // The same work is already in progress
                   return false;
               }
           }
   // No task associated with the ImageView, or an existing task was cancelled
           return true;
       }
       private static BitmapWorkerTask getBitmapWorkerTask(ImageView imageView) {
          if (imageView != null) {
              final Drawable drawable = imageView.getDrawable();
              if (drawable instanceof AsyncDrawable) {
                  final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;
                  return asyncDrawable.getBitmapWorkerTask();
              }
           }
           return null;
       }
       ... // include updated BitmapWorkerTask class

   注意，将上述代码做适当修改还可以应用在 ListView 中。
   上述代码实现中，让我们可以灵活的加载并处理图片，而且还不影响用户的使用体验。在后台的任务中，你可以从网络中加载图片，并调整高清图片的大小，在任务结束后再展现处理后的图片。